Determining whether London streets are air quality canyons

Loading libraries

rm(list=ls(all=TRUE)) 

library(devtools)
#suppressMessages(devtools::install_github("r-spatial/sf"))
library(sf)
#suppressMessages(devtools::install_github("ropensci/osmdata"))
suppressMessages(library(osmdata))
suppressMessages(library(raster))
#suppressMessages(devtools::install_github("tidyverse/ggplot2"))
library(ggplot2)
library(rgeos)
library(maptools)
library(rgdal)
library(rgeos)
library(data.table)
library(knitr)
suppressMessages(library(mapview))
library(RCurl)
library(stplanr)

Import building height data

Building height data is downloaded from Copernicus Urban Atlas, unzipped and extracted.

The methodology for their creation, by [gaf.d])(https://www.gaf.de/), was as following: “Our original input data were Cartosat-1 acquisitions. The following processing system uses a customised and specialised semi-global matching algorithm to generate am 3m in close cooperation with DLR (German Aerospace Center). Subsequent to the highly automated DSM generation, a DTM was calculated and a nDSM (normalised Digital Surface Model) derived by using internal software and processing tools. The nDSM were finally resampled from 3m up to 10m resolution by using the maximum height value”.

This raster is then imported.

london_raster <- raster('buildings_raster/UK001L2_LONDON_UA2012_DHM/UK001L2_LONDON_UA2012_DHM.tif')
plot(london_raster)
title('Raster file of London Building heights')

plot(london_raster, xlim = c(3615000, 3625000), ylim = c(3200000, 3205000))
title('Raster file of London Building heights (zoomed)')

Import OSM roads data

First we get the extent of the raster

extent              <- extent(london_raster)
extent              <- as(extent, 'SpatialPolygons')
proj4string(extent) <- crs(london_raster)
latlong             <- CRS("+init=epsg:4326")
extent              <- spTransform(extent, latlong)

min_x   <- extent(extent)[1]
max_x   <- extent(extent)[2]
min_y   <- extent(extent)[3]
max_y   <- extent(extent)[4]
rm(extent)

Now using the osmdata package we can download osmdata for the extent we just defined. Roads have the value ‘highway’ in OpenStreetMap. Within that heading, we can also filter using the following tags:

available_tags('highway')

##  [1] "bridleway"              "bus guideway"          
##  [3] "bus stop"               "construction"          
##  [5] "crossing"               "cycleway"              
##  [7] "elevator"               "emergency access point"
##  [9] "escape"                 "footway"               
## [11] "give way"               "living street"         
## [13] "mini roundabout"        "motorway"              
## [15] "motorway junction"      "motorway link"         
## [17] "passing place"          "path"                  
## [19] "pedestrian"             "primary"               
## [21] "primary link"           "proposed"              
## [23] "raceway"                "residential"           
## [25] "rest area"              "road"                  
## [27] "secondary"              "secondary link"        
## [29] "service"                "services"              
## [31] "speed camera"           "steps"                 
## [33] "stop"                   "street lamp"           
## [35] "tertiary"               "tertiary link"         
## [37] "track"                  "traffic signals"       
## [39] "trunk"                  "trunk link"            
## [41] "turning circle"         "unclassified"

Now we import OSM roads data for the following road types.

primary           <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='primary') %>% osmdata_sf()
primary           <- primary$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
primary$type      <- 'primary'

primary_link      <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='primary_link') %>% osmdata_sf()
primary_link      <- primary_link$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
primary_link$type <- 'primary_link'

secondary         <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='secondary') %>% osmdata_sf()
secondary         <- secondary$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
secondary$type    <- 'secondary'

motorway          <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='motorway') %>% osmdata_sf()
motorway          <- motorway$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
motorway$type     <- 'motorway'

motorway_link     <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='motorway_link') %>% osmdata_sf()
motorway_link     <- motorway_link$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
motorway_link$type <- 'motorway_link'

trunk             <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='trunk') %>% osmdata_sf()
trunk             <- trunk$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
trunk$type        <- 'trunk'

trunk_link        <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='trunk_link') %>% osmdata_sf()
trunk_link        <- trunk_link$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
trunk_link$type   <- 'trunk_link'

tertiary          <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='tertiary') %>% osmdata_sf()
tertiary          <- tertiary$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
tertiary$type     <- 'tertiary'

Then bind them all into one object

roads             <- rbind(primary, primary_link, secondary, motorway, motorway_link, trunk, trunk_link, tertiary) 

roads$osm_id      <- as.numeric(as.character(roads$osm_id))

rm(primary, primary_link, secondary, motorway, motorway_link, trunk, trunk_link, tertiary)

Now that we have a SpatialLinesDataFrame of all the London roads, we delete the ones where the ‘lane’ attribute is not formed properly or contains an error.

roads$lanes       <- as.character(roads$lanes)
roads             <- roads[!grepl(';', roads$lanes),]
roads$lanes       <- as.numeric(roads$lanes)

The number of lanes for each road type is below.

table(roads$type, roads$lanes)

##                
##                    1  1.5    2    3    4    5    6    8
##   motorway         2    0  149  544  314   57   15    0
##   motorway_link  150    0  350   42   12    1    0    0
##   primary       1000    0 3226  836  217   49    3    0
##   primary_link   202    0   84   11    0    0    0    0
##   secondary      289    0  825   43    5    1    0    0
##   tertiary       487    6 1273   91   14    1    0    0
##   trunk          262    0 2768 1775  578   87   25    2
##   trunk_link     314    0  347   27   12    0    0    0

Where this is missing, we fill in the blanks, using the mean values of that road type, rounded.

roads[roads$type == 'primary'       & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'primary'       & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'primary_link'  & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'primary_link'  & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'secondary'     & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'secondary'     & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'motorway'      & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'motorway'      & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'motorway_link' & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'motorway_link' & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'trunk'         & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'trunk'         & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'trunk_link'    & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'trunk_link'    & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'tertiary'      & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'tertiary'      & !is.na(roads$lanes),]$lanes),0)

Now, presuming that a lane is 3.15 metres wide, each road width is now calculated and added to the dataset.

roads$width             <- as.numeric(roads$lanes) * 3.15

OSM splits some roads into two, like Marylebone Road, and motorways. This is a problem for calculating height to width ratios. So we are going to try and identify these.

roads$half_of_one <- NA

roads[roads$oneway == 'yes' & !is.na(roads$oneway) & roads$type == 'trunk'           & !is.na(roads$type),'half_of_one'] <- as.character('Yes')
roads[roads$oneway == 'yes' & !is.na(roads$oneway) & roads$type == 'trunk_link'      & !is.na(roads$type),'half_of_one'] <- as.character('Yes')

roads[roads$oneway == 'yes' & !is.na(roads$oneway) & roads$type == 'motorway'        & !is.na(roads$type),'half_of_one'] <- as.character('Yes')
roads[roads$oneway == 'yes' & !is.na(roads$oneway) & roads$type == 'motorway_link'   & !is.na(roads$type),'half_of_one'] <- as.character('Yes')

The road widths by road type are now as below

ggplot(roads, aes(x = width, fill=type)) + geom_histogram(alpha=0.3) + facet_wrap(.~type, scales="free") + ggtitle('Road widths by road type')

## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

The widest road in the dataset is here

m <- mapview(st_buffer(st_transform(roads[roads$width>25,][1,],27700),100), map.types = 'Esri.WorldImagery', alpha.regions=0.1)
mapshot(m, file = paste0(getwd(), "/map.png"), remove_controls = c("zoomControl", "layersControl", "homeButton","scaleBar"))

Pavement width is also added to the roads, depending on what type of road it is, as follows. Presumes 3 metres wide pavement. For motorways we still add ‘pavement’ but presume this is hard-shoulder.

roads$pavement_width   <- NA

roads[roads$type == 'primary'        & is.na(roads$half_of_one),  'pavement_width'] <- 6
roads[roads$type == 'primary_link'   & is.na(roads$half_of_one),  'pavement_width'] <- 6

roads[roads$type == 'secondary'      & is.na(roads$half_of_one),  'pavement_width'] <- 6

roads[roads$type == 'motorway'       & is.na(roads$half_of_one),  'pavement_width'] <- 6
roads[roads$type == 'motorway_link'  & is.na(roads$half_of_one),  'pavement_width'] <- 6

roads[roads$type == 'trunk'          & is.na(roads$half_of_one),  'pavement_width'] <- 6
roads[roads$type == 'trunk_link'     & is.na(roads$half_of_one),  'pavement_width'] <- 6

roads[roads$type == 'tertiary'       & is.na(roads$half_of_one),  'pavement_width'] <- 6

roads[roads$type == 'primary'        & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3
roads[roads$type == 'primary_link'   & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3

roads[roads$type == 'secondary'      & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3

roads[roads$type == 'motorway'       & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3
roads[roads$type == 'motorway_link'  & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3

roads[roads$type == 'trunk'          & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3
roads[roads$type == 'trunk_link'     & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3

roads[roads$type == 'tertiary'       & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3

roads$total_width <- roads$width + roads$pavement_width

Road widths are now

ggplot(roads, aes(x = total_width, fill=type)) + geom_histogram(alpha=0.3) + facet_wrap(.~type, scales="free") + ggtitle('Road widths by road type')

## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

Add half central reservation

roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width <- roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width + 2

With pavements added the roads width is..

ggplot(roads, aes(x = total_width, fill=type)) + geom_histogram(alpha=0.3) + facet_wrap(.~type, scales="free") + ggtitle('Road widths by road type')

## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

As a table the road widths

table(roads$type, roads$total_width)

##                
##                  8.15  9.15 10.725  11.3  12.3 14.45 15.45  17.6  18.6
##   motorway          2     0      0   149     0   554    10   314     0
##   motorway_link   148     2      0   462     8    42     0    12     0
##   primary           0  1000      0     0 14153     0   836     0   217
##   primary_link      0   680      0     0    84     0    11     0     0
##   secondary         0   289      0     0  5502     0    43     0     5
##   tertiary          0   487      6     0 12844     0    91     0    14
##   trunk           258     4      0  2245   523  2770   973   320   258
##   trunk_link      313     1      0   933    25    27     0    12     0
##                
##                 20.75 21.75  23.9  24.9  30.2
##   motorway         57     0    15     0     0
##   motorway_link     1     0     0     0     0
##   primary           0    49     0     3     0
##   primary_link      0     0     0     0     0
##   secondary         0     1     0     0     0
##   tertiary          0     1     0     0     0
##   trunk            52    35    18     7     2
##   trunk_link        0     0     0     0     0

As a table the road lanes

table(roads$type, roads$lanes)

##                
##                     1   1.5     2     3     4     5     6     8
##   motorway          2     0   149   564   314    57    15     0
##   motorway_link   150     0   470    42    12     1     0     0
##   primary        1000     0 14153   836   217    49     3     0
##   primary_link    680     0    84    11     0     0     0     0
##   secondary       289     0  5502    43     5     1     0     0
##   tertiary        487     6 12844    91    14     1     0     0
##   trunk           262     0  2768  3743   578    87    25     2
##   trunk_link      314     0   958    27    12     0     0     0

The map below shows roads currently in the dataset, coloured by type

ggplot(roads, aes(colour = type, fill=type)) + 
  geom_sf() +
  ggtitle('Downloaded OSM roads, by road type') +
  theme(axis.text = element_blank(),
        panel.background = element_blank(),
        axis.ticks = element_blank(),
        legend.position = 'bottom')

Remove a few circular roads that are a problem for buffers

roads_to_ignore         <- c(9393,11079,14595,15578)
roads                   <- roads[-roads_to_ignore,]
rm(roads_to_ignore)

Make the buffers around the roads

roads                   <- st_transform(roads, 27700)

roads$area              <- st_geometry(st_buffer(roads, dist = 15)) / st_geometry(st_buffer(roads, dist = 10))

For the roads like Marylebone Road, going to double the buffer area and add 5 metres to the buffers.

roads[!is.na(roads$half_of_one),]$area              <- st_geometry(st_buffer(roads[!is.na(roads$half_of_one),], dist = 15*2+5)) /
                                                       st_geometry(st_buffer(roads[!is.na(roads$half_of_one),], dist = 10*2+5))

Transform the buffers to the same CRS as the raster we’re going to extract from.

roads$geometry          <- st_transform(roads$geometry,4326)
roads$area              <- st_transform(roads$area, 4326)

roads$geometry          <- st_transform(roads$geometry, crs(london_raster)@projargs)
roads$area              <- st_transform(roads$area, crs(london_raster)@projargs)

Check everything looks ok

plot(london_raster, xlim=c(3621000, 3622000), ylim = c(3204000,3205000))
plot(st_geometry(roads), xlim=c(3621000, 3622000), add=T)
plot(st_geometry(roads$area), xlim=c(3621000, 3622000), add=T)

Interactive map view of one feature

osm_id_to_examine <- 379356929

temp_raster <- extent(st_bbox(roads[roads$osm_id == osm_id_to_examine,])$xmin-40, st_bbox(roads[roads$osm_id == osm_id_to_examine,])$xmax+40, 
                      st_bbox(roads[roads$osm_id == osm_id_to_examine,])$ymin-40, st_bbox(roads[roads$osm_id == osm_id_to_examine,])$ymax+40)
temp_raster <- crop(london_raster, temp_raster)

mapview(temp_raster, alpha.regions = 0.4, map.types = 'OpenStreetMap.BlackAndWhite') %>% addFeatures(st_transform(roads[roads$osm_id == osm_id_to_examine,],4326))

rm(temp_raster, osm_id_to_examine)

Now extract the data we need from the raster (this takes circa 12 hours)

start_time          <- Sys.time()

road_polygons       <- as(roads$area,'Spatial')
roads$area          <- NULL 

roads$weighted_mean <- NA
roads$cell_count    <- NA
roads$zero_cells    <- NA

print('about extracting data')

extracted <- extract(london_raster, road_polygons, weights=T, na.rm=F)

print('extracted data, using sapply to put into the roads file')

roads$weighted_mean                           <- sapply(extracted, FUN = function(x)(sum(x[,1] * x[,2])))
roads$cell_count                              <- sapply(extracted, FUN = function(x)(length(x[,1])))
roads$zero_cells                              <- sapply(extracted, FUN = function(x)(sum(x[,1]==0)))
roads$max_height                              <- sapply(extracted, FUN = function(x)(max(x[,1], na.rm=T)))

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

roads$non_zero_means                          <- sapply(extracted, FUN = function(x)(sum(x[x[,1]>0,1] * (x[x[,1]>0,2] / sum(x[x[,1]>0,2])))))

roads[roads$max_height == '-Inf',]$max_height <- NA

print('done')

roads$geometry      <- st_transform(roads$geometry, 4326)

rm(london_raster)

end_time <- Sys.time()

print(end_time - start_time)

rm(start_time, end_time)

Now need to get the bearing of each road from start point to end point

roads$bearing             <- line_bearing(roads)

hist(roads$bearing)

Where the road is ‘half of one’, double the width of the road

roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width <- roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width * 2

Add another column for height to width ratio

roads$height_width_ratio <- roads$weighted_mean / roads$total_width

Add another height widhth ratio column for when using the non-zero height from the raster

roads$height_width_ratio_excl_zeros <- roads$non_zero_means / roads$total_width

Now plot the non-zero height/width ratios.

ggplot(roads, aes(y = height_width_ratio, group=type, x=type, fill=type)) + geom_boxplot() + ggtitle('Height to width ratio by street type')

## Warning: Removed 8252 rows containing non-finite values (stat_boxplot).

Need to classify the roads as canyons and directions for modelling. If the height is above 10 metres they will be classified as a low canyon, above 20, a medium canyon, above 30 a high canyon + a specific directio.

roads$classification     <- NA 

First the North-South canyon road type (type 1)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= -22.5   & roads$bearing <= 22.5,]$classification    <- '1a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 157.5   & roads$bearing <= 180,]$classification     <- '1a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing <= -157.5  & roads$bearing > -180,]$classification     <- '1a'


roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= -22.5   & roads$bearing <= 22.5,]$classification  <- '1b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 157.5   & roads$bearing <= 180,]$classification   <- '1b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing <= -157.5  & roads$bearing > -180,]$classification   <- '1b'

roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= -22.5   & roads$bearing <= 22.5,]$classification  <- '1c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= 157.5   & roads$bearing <= 180,]$classification   <- '1c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing <= -157.5  & roads$bearing > -180,]$classification   <- '1c'

Now the East-West canyon road type (type 2)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 67.5    & roads$bearing <= 112.5,]$classification <- '2a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= -112.5  & roads$bearing <= -67.5,]$classification <- '2a'

roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 67.5    & roads$bearing <= 112.5,]$classification <- '2b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= -112.5  & roads$bearing <= -67.5,]$classification <- '2b'

roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= 67.5    & roads$bearing <= 112.5,]$classification <- '2c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= -112.5  & roads$bearing <= -67.5,]$classification <- '2c'

Now the South-East to North-West canyon road type (type 3)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 112.5    & roads$bearing <= 157.5,]$classification  <- '3a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing <= -22.5  & roads$bearing   >= -67.5,]$classification  <- '3a'

roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 112.5    & roads$bearing <= 157.5,]$classification  <- '3b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing <= -22.5  & roads$bearing   >= -67.5,]$classification  <- '3b'

roads[roads$non_zero_means > 30  & !is.na(roads$non_zero_means) & roads$bearing >= 112.5    & roads$bearing <= 157.5,]$classification  <- '3c'
roads[roads$non_zero_means > 30  & !is.na(roads$non_zero_means) & roads$bearing <= -22.5  & roads$bearing   >= -67.5,]$classification  <- '3c'

Now the South-West to North-East canyon road type (type 4)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 22.5    & roads$bearing  <= 67.5,]$classification   <- '4a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing <= -112.5  & roads$bearing >= -157.5,]$classification  <- '4a'

roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 22.5    & roads$bearing  <= 67.5,]$classification   <- '4b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing <= -112.5  & roads$bearing >= -157.5,]$classification  <- '4b'

roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= 22.5    & roads$bearing  <= 67.5,]$classification   <- '4c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing <= -112.5  & roads$bearing >= -157.5,]$classification  <- '4c'

Now non-street-canyons that are open roads are classified as type 5. There are 12079 of these.

roads[roads$non_zero_means <= 1 & !is.na(roads$non_zero_means) ,]$classification   <- 5 #open

Now non-street-canyons that are typical roads are classified as type 6. There are 19990 of these.

roads[roads$non_zero_means > 1 & roads$non_zero_means <= 10 & !is.na(roads$non_zero_means) ,]$classification    <- 6 #typical

Haven’t been working on them, but think it’s time time to add the residential roads back in and harmonise them with the main roads data.

residential           <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='residential') %>% osmdata_sf()
residential           <- residential$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
residential$type      <- 'residential'

service               <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='service') %>% osmdata_sf()
service               <- residential$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
service$type          <- 'service'

unclassified           <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='unclassified') %>% osmdata_sf()
unclassified           <- residential$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
unclassified$type      <- 'unclassified'

residential$osm_id      <- as.numeric(as.character(residential$osm_id))

residential$lanes       <- as.character(residential$lanes)
residential             <- residential[!grepl(';', residential$lanes),]
residential$lanes       <- as.numeric(residential$lanes)

residential[is.na(residential$lanes),'lanes'] <- 2

residential$width                           <- residential$lanes * 3.15
residential$half_of_one                     <- as.character(NA)
residential$pavement_width                  <- as.numeric(6)
residential$total_width                     <- as.numeric(residential$width + residential$pavement_width)
residential$weighted_mean                   <- as.numeric(NA)
residential$cell_count                      <- as.integer(NA)
residential$zero_cells                      <- as.integer(NA)
residential$bearing                         <- as.numeric(NA)
residential$height_width_ratio              <- as.numeric(NA)
residential$max_height                      <- as.numeric(NA)
residential$non_zero_means                  <- as.numeric(NA)
residential$height_width_ratio_excl_zeros   <- as.numeric(NA)
residential$classification                  <- as.numeric(6)

col_order <- names(roads)

residential <- residential[,col_order]

roads <- rbind(roads, residential)

rm(residential)

Now get the median height and width for each road type

road_characteristics <- data.frame(aggregate(data = roads, cbind(total_width, non_zero_means) ~ classification, FUN=mean))

kable(road_characteristics)

classification	total_width	non_zero_means
1a	15.27961	13.541729
1b	15.08723	24.309572
1c	14.56591	39.541403
2a	16.22108	13.606470
2b	16.13391	23.913944
2c	15.73178	42.442955
3a	16.06628	13.433115
3b	15.79116	24.129052
3c	17.24878	39.562910
4a	15.54725	13.674695
4b	15.59673	23.795894
4c	18.04279	42.318706
5	14.34547	0.000000
6	14.46132	7.304262

st_write(roads, 'final_roads_london.geojson', delete_dsn = T)

## Deleting source `/home/james/github/london_osm_canyons/final_roads_london.geojson' using driver `GeoJSON'
## Writing layer `final_roads_london' to data source `/home/james/github/london_osm_canyons/final_roads_london.geojson' using driver `GeoJSON'
## features:       147687
## fields:         17
## geometry type:  Line String

#roads$type        <- as.character(roads$type)

#roads[roads$type %in% c('primary', 'trunk'),'type']             <- 'primary'

#roads[!roads$type %in% c('motorway','primary', 'trunk'),'type'] <- 'other'